library(nycflights13)
library(tidyverse)

-- Attaching packages --------------------------------------- tidyverse 1.2.1 --
v ggplot2 3.0.0     v purrr   0.2.5
v tibble  1.4.2     v dplyr   0.7.6
v tidyr   0.8.1     v stringr 1.3.1
v readr   1.1.1     v forcats 0.3.0
-- Conflicts ------------------------------------------ tidyverse_conflicts() --
x dplyr::filter() masks stats::filter()
x dplyr::lag()    masks stats::lag()

flights

# filter by flights on the 1st of january
(jan1 <- filter(flights, month == 1, day == 1))

sqrt(2) ^ 2 == 2

[1] FALSE

1 / 49 * 49 == 1

[1] FALSE

near(sqrt(2) ^ 2, 2)

[1] TRUE

near(1 / 49 * 49, 1)

[1] TRUE

(nov_dec <- filter(flights, month == 11 | month == 12))

# using shorthand
(nov_dec <- filter(flights, month %in% c(11, 12)))

# using demorgan's
(delay_range1 <- filter(flights, !(arr_delay > 120 | dep_delay > 120)))

NA > 5

[1] NA

10 == NA

[1] NA

NA == NA

[1] NA

x <- NA
is.na(x)

[1] TRUE

df <- tibble(x = c(1, NA, 3))
filter(df, x > 1)

filter(df, is.na(x) | x > 1)

# 1
filter(flights, arr_delay >= 120)

filter(flights, dest == "IAH" | dest == "HOU")

filter(flights, carrier == "UA" | carrier == "AA" | carrier == "DL")

filter(flights, month %in% c(7, 8, 9))

filter(flights, dep_delay <= 0, arr_delay > 120)

filter(flights, dep_delay >= 60, dep_delay - arr_delay > 30)

filter(flights, between(dep_time, 0, 600) | dep_time == 2400)

filter(flights, is.na(dep_time))

arrange(flights, year, month, day)

arrange(flights, desc(dep_delay))

arrange(flights, dep_delay)

# Missing values are always sorted at the end
df <- tibble(x = c(5, 2, NA))
arrange(df, x)

arrange(df, desc(x))

# 1
arrange(flights, desc(is.na(dep_time)), dep_time)

# 2
# Most delayed
arrange(flights, desc(dep_delay))

# Earliest
arrange(flights, dep_delay)

# 3
# total air time
arrange(flights, air_time)

# average air time
arrange(flights, distance / air_time * 60)

# 4
# interpretation 1
arrange(flights, desc(distance))

arrange(flights, distance)

# interpretation 2
arrange(flights, desc(air_time))

arrange(flights, air_time)

select(flights, year, month, day)

# Select range of columns
select(flights, year:day)

# Exclude columns
select(flights, -(year:day))

rename(flights, tail_num = tailnum)

# Move some variables to the start of the dataframe
select(flights, time_hour, air_time, everything())

# 1
select(flights, dep_time, dep_delay, arr_time, arr_delay)

select(flights, "dep_time", "dep_delay", "arr_time", "arr_delay")

select(flights, starts_with("dep_"), starts_with("arr_"))

select(flights, 4, 6, 7, 9)

select(flights, matches("^(dep|arr)_(delay|time)$"))

of_interest <- c("dep_time", "dep_delay", "arr_time", "arr_delay")
select(flights, one_of(of_interest))

# 2
select(flights, dep_time, dep_time)

# 4
select(flights, contains("TIME"))

select(flights, contains("TIME", ignore.case = FALSE))

(flights_sml <- select(
  flights,
  year:day,
  ends_with("delay"),
  distance,
  air_time
))

# add some columns
(mutate(
  flights_sml,
  gain = dep_delay - arr_delay,
  speed = distance / air_time * 60
))

# Use new columns for an opperation
(mutate(
  flights_sml,
  gain = dep_delay - arr_delay,
  hours = air_time / 60,
  gain_per_hour = gain / hours
))

# Only keep the new variables
(transmute(
  flights,
  gain = dep_delay - arr_delay,
  hours = air_time / 60,
  gain_per_hour = gain / hours
))

# Using other functions
(transmute(
  flights,
  dep_time,
  hour = dep_time %/% 100,
  minute = dep_time %% 100
))

# Lag and Lead
(x <- 1:10)

 [1]  1  2  3  4  5  6  7  8  9 10

lag(x)

 [1] NA  1  2  3  4  5  6  7  8  9

lead(x)

 [1]  2  3  4  5  6  7  8  9 10 NA

# Running aggregates
cumsum(x)

 [1]  1  3  6 10 15 21 28 36 45 55

cummean(x)

 [1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0 5.5

# Ranking
y <- c(2, 3, 3, NA, 4, 7)
min_rank(y)

[1]  1  2  2 NA  4  5

min_rank(desc(y))

[1]  5  3  3 NA  2  1

row_number(y)

[1]  1  2  3 NA  4  5

dense_rank(y)

[1]  1  2  2 NA  3  4

cume_dist(y)

[1] 0.2 0.6 0.6  NA 0.8 1.0

# 1
# Midnight is represented as 2400 -> 24 * 60 = 1440 minutes after midnight (need to account for this)
time_to_mins <- function(t) {
  return((t %/% 100 * 60 + t %% 100) %% 1440)
}
(flight_times <- mutate(
  flights,
  dep_time_mins = time_to_mins(dep_time),
  sched_dep_time_mins = time_to_mins(sched_dep_time)
))

select(flight_times, dep_time, sched_dep_time, dep_time_mins, sched_dep_time_mins)

# 2
# Grab rows of interest
(flight_durs <- select(flights, arr_time, dep_time, air_time, origin, dest))

# Convert them all to minutes (except air time, which already is)
(flight_durs <- mutate(
  flight_durs,
  arr_time_mins = time_to_mins(arr_time),
  dep_time_mins = time_to_mins(dep_time)
))

# Rearrange columns
flight_durs <- select(flight_durs, origin, dest, air_time, everything())
# Calculate air_time_diff
(flight_durs <- mutate(flight_durs, air_time_diff = arr_time_mins - dep_time_mins))

# Check if it worked. Are there negatives?
arrange(flight_durs, air_time_diff)

# There are, so flights that go overnight are incorrect. Also, timezones could cause problems
# 3
# SHould be difference between dep time and scheduled dep time
flights_deptime <- 
  mutate(
    flights,
    dep_time_mins = time_to_mins(dep_time),
    sched_dep_time_mins = time_to_mins(sched_dep_time),
    dep_delay_mins = dep_time_mins - sched_dep_time_mins
  )
# Have same issue that overnight delays appear as <= 0

# 4
(most_delayed <- select(
  mutate(
    flights,
    dep_delay_rank = min_rank(desc(dep_delay))
  ),
  dep_delay_rank,
  dep_delay,
  everything()
  )
 )

arrange(most_delayed, dep_delay)

# Only grab the 50 most delayed (there are no repeats in the top 10)
(top_50 <- arrange(
  filter(most_delayed, dep_delay_rank <= 50),
  dep_delay_rank)
)

# 5
1:3 + 1:10

longer object length is not a multiple of shorter object length

 [1]  2  4  6  5  7  9  8 10 12 11

summarise(flights, delay = mean(dep_delay, na.rm = TRUE))

by_day <- group_by(flights, year, month, day)
summarize(by_day, delay = mean(dep_delay, na.rm = TRUE))

# Group flights by destination
by_dest <- group_by(flights, dest)
# Summarize distance, avg. delay, number of flights
(delays <- summarize(
  by_dest,
  count = n(),
  dist = mean(distance, na.rm = TRUE),
  delay = mean(arr_delay, na.rm = TRUE)
))

# Honolulu is quite far away from all others
arrange(delays, desc(dist))

# Ignore destinations that rarely occur
arrange(delays, count)

# Filter to remove noise (I.E. Honolulu and destinations with a very small number of flights)
(delays <- filter(delays, count > 20, dest != "HNL"))

# Visualize the data
ggplot(data = delays, mapping = aes(x = dist, y = delay)) +
  geom_point(aes(size = count), alpha = 1/3) +
  geom_smooth(se = FALSE)

# Do the same thing using pipes
# Note: x %>% f(y) == f(x, y) and x %>% f(y) %>% g(z) == g(f(x, y), z)
(delays <- flights %>%
  group_by(dest) %>%
  summarize(
    count = n(),
    dist = mean(distance, na.rm = TRUE),
    delay = mean(arr_delay, na.rm = TRUE)
  ) %>%
  filter(count > 20, dest != "HNL") %>%
  arrange(desc(delay))
)

# Reason for using na.rm
flights %>%
  group_by(year, month, day) %>%
  summarize(mean = mean(dep_delay))

# Fixed
flights %>%
  group_by(year, month, day) %>%
  summarize(mean = mean(dep_delay, na.rm = TRUE))

# Remove cancelled flights from the data set
not_cancelled <- flights %>%
  filter(!is.na(dep_delay), !is.na(arr_delay))
not_cancelled %>%
  group_by(year, month, day) %>%
  summarize(mean = mean(dep_delay))

# Find individual planes (identified by tail num) and their average delays
delays <- not_cancelled %>%
  group_by(tailnum) %>%
  summarize(
    delay = mean(arr_delay)
  )
ggplot(data = delays, mapping = aes(x = delay)) +
  geom_freqpoly(binwidth = 10)

# Try with number of flights vs avg delay
delays <- not_cancelled %>%
  group_by(tailnum) %>%
  summarize(
    delay = mean(arr_delay),
    n = n()
  )
ggplot(data = delays, mapping = aes(x = n, y = delay)) +
  geom_point(alpha = 1/10)

---
title: "Chapter 5"
output: html_notebook
---


```{r}
library(nycflights13)
library(tidyverse)
```

# nycflights13
```{r}
flights
```

# Filter Rows
```{r}
# filter by flights on the 1st of january
(jan1 <- filter(flights, month == 1, day == 1))
```

# Comparisons
```{r}
sqrt(2) ^ 2 == 2
1 / 49 * 49 == 1
near(sqrt(2) ^ 2, 2)
near(1 / 49 * 49, 1)

```

# Logical operators
```{r}
(nov_dec <- filter(flights, month == 11 | month == 12))

# using shorthand
(nov_dec <- filter(flights, month %in% c(11, 12)))
# using demorgan's
(delay_range1 <- filter(flights, !(arr_delay > 120 | dep_delay > 120)))
```

# Missing Values
```{r}
NA > 5
10 == NA
NA == NA
x <- NA
is.na(x)
df <- tibble(x = c(1, NA, 3))
filter(df, x > 1)
filter(df, is.na(x) | x > 1)
```

# Exercises
```{r}
# 1
filter(flights, arr_delay >= 120)
filter(flights, dest == "IAH" | dest == "HOU")
filter(flights, carrier == "UA" | carrier == "AA" | carrier == "DL")
filter(flights, month %in% c(7, 8, 9))
filter(flights, dep_delay <= 0, arr_delay > 120)
filter(flights, dep_delay >= 60, dep_delay - arr_delay > 30)
filter(flights, between(dep_time, 0, 600) | dep_time == 2400)
filter(flights, is.na(dep_time))
```

# Arrange Rows
```{r}
arrange(flights, year, month, day)
arrange(flights, desc(dep_delay))
arrange(flights, dep_delay)

# Missing values are always sorted at the end
df <- tibble(x = c(5, 2, NA))
arrange(df, x)
arrange(df, desc(x))
```

# Exercises
```{r}
# 1
arrange(flights, desc(is.na(dep_time)), dep_time)
# 2
# Most delayed
arrange(flights, desc(dep_delay))
# Earliest
arrange(flights, dep_delay)
# 3
# total air time
arrange(flights, air_time)
# average air time
arrange(flights, distance / air_time * 60)
# 4
# interpretation 1
arrange(flights, desc(distance))
arrange(flights, distance)
# interpretation 2
arrange(flights, desc(air_time))
arrange(flights, air_time)
```

# Select Columns
```{r}
select(flights, year, month, day)
# Select range of columns
select(flights, year:day)
# Exclude columns
select(flights, -(year:day))
rename(flights, tail_num = tailnum)
# Move some variables to the start of the dataframe
select(flights, time_hour, air_time, everything())
```

# Exercises
```{r}
# 1
select(flights, dep_time, dep_delay, arr_time, arr_delay)
select(flights, "dep_time", "dep_delay", "arr_time", "arr_delay")
select(flights, starts_with("dep_"), starts_with("arr_"))
select(flights, 4, 6, 7, 9)
select(flights, matches("^(dep|arr)_(delay|time)$"))
of_interest <- c("dep_time", "dep_delay", "arr_time", "arr_delay")
select(flights, one_of(of_interest))
# 2
select(flights, dep_time, dep_time)

# 4
select(flights, contains("TIME"))
select(flights, contains("TIME", ignore.case = FALSE))
```

# Add new variables
```{r}
(flights_sml <- select(
  flights,
  year:day,
  ends_with("delay"),
  distance,
  air_time
))

# add some columns
(mutate(
  flights_sml,
  gain = dep_delay - arr_delay,
  speed = distance / air_time * 60
))

# Use new columns for an opperation
(mutate(
  flights_sml,
  gain = dep_delay - arr_delay,
  hours = air_time / 60,
  gain_per_hour = gain / hours
))

# Only keep the new variables
(transmute(
  flights,
  gain = dep_delay - arr_delay,
  hours = air_time / 60,
  gain_per_hour = gain / hours
))

# Using other functions
(transmute(
  flights,
  dep_time,
  hour = dep_time %/% 100,
  minute = dep_time %% 100
))

# Lag and Lead
(x <- 1:10)
lag(x)
lead(x)

# Running aggregates
cumsum(x)
cummean(x)

# Ranking
y <- c(2, 3, 3, NA, 4, 7)
min_rank(y)
min_rank(desc(y))
row_number(y)
dense_rank(y)
cume_dist(y)
```

# Exercises
```{r}
# 1
# Midnight is represented as 2400 -> 24 * 60 = 1440 minutes after midnight (need to account for this)
time_to_mins <- function(t) {
  return((t %/% 100 * 60 + t %% 100) %% 1440)
}

(flight_times <- mutate(
  flights,
  dep_time_mins = time_to_mins(dep_time),
  sched_dep_time_mins = time_to_mins(sched_dep_time)
))

select(flight_times, dep_time, sched_dep_time, dep_time_mins, sched_dep_time_mins)

# 2
# Grab rows of interest
(flight_durs <- select(flights, arr_time, dep_time, air_time, origin, dest))
# Convert them all to minutes (except air time, which already is)
(flight_durs <- mutate(
  flight_durs,
  arr_time_mins = time_to_mins(arr_time),
  dep_time_mins = time_to_mins(dep_time)
))
# Rearrange columns
flight_durs <- select(flight_durs, origin, dest, air_time, everything())
# Calculate air_time_diff
(flight_durs <- mutate(flight_durs, air_time_diff = arr_time_mins - dep_time_mins))
# Check if it worked. Are there negatives?
arrange(flight_durs, air_time_diff)
# There are, so flights that go overnight are incorrect. Also, timezones could cause problems

# 3
# SHould be difference between dep time and scheduled dep time
flights_deptime <- 
  mutate(
    flights,
    dep_time_mins = time_to_mins(dep_time),
    sched_dep_time_mins = time_to_mins(sched_dep_time),
    dep_delay_mins = dep_time_mins - sched_dep_time_mins
  )
# Have same issue that overnight delays appear as <= 0
```

# Exercises (cont.)
```{r}
# 4
(most_delayed <- select(
  mutate(
    flights,
    dep_delay_rank = min_rank(desc(dep_delay))
  ),
  dep_delay_rank,
  dep_delay,
  everything()
  )
 )
arrange(most_delayed, dep_delay)
# Only grab the 50 most delayed (there are no repeats in the top 10)
(top_50 <- arrange(
  filter(most_delayed, dep_delay_rank <= 50),
  dep_delay_rank)
)

# 5
1:3 + 1:10
# keeps cycling 1:3 until reach 10
```

# Grouped Summaries
```{r}
summarise(flights, delay = mean(dep_delay, na.rm = TRUE))
by_day <- group_by(flights, year, month, day)
summarize(by_day, delay = mean(dep_delay, na.rm = TRUE))

# Group flights by destination
by_dest <- group_by(flights, dest)
# Summarize distance, avg. delay, number of flights
(delays <- summarize(
  by_dest,
  count = n(),
  dist = mean(distance, na.rm = TRUE),
  delay = mean(arr_delay, na.rm = TRUE)
))
# Honolulu is quite far away from all others
arrange(delays, desc(dist))
# Ignore destinations that rarely occur
arrange(delays, count)
# Filter to remove noise (I.E. Honolulu and destinations with a very small number of flights)
(delays <- filter(delays, count > 20, dest != "HNL"))

# Visualize the data
ggplot(data = delays, mapping = aes(x = dist, y = delay)) +
  geom_point(aes(size = count), alpha = 1/3) +
  geom_smooth(se = FALSE)

# Do the same thing using pipes
# Note: x %>% f(y) == f(x, y) and x %>% f(y) %>% g(z) == g(f(x, y), z)
(delays <- flights %>%
  group_by(dest) %>%
  summarize(
    count = n(),
    dist = mean(distance, na.rm = TRUE),
    delay = mean(arr_delay, na.rm = TRUE)
  ) %>%
  filter(count > 20, dest != "HNL") %>%
  arrange(desc(delay))
)

# Reason for using na.rm
flights %>%
  group_by(year, month, day) %>%
  summarize(mean = mean(dep_delay))
# Fixed
flights %>%
  group_by(year, month, day) %>%
  summarize(mean = mean(dep_delay, na.rm = TRUE))

# Remove cancelled flights from the data set
not_cancelled <- flights %>%
  filter(!is.na(dep_delay), !is.na(arr_delay))

not_cancelled %>%
  group_by(year, month, day) %>%
  summarize(mean = mean(dep_delay))
```

# Grouped Summaries (cont.)
```{r}
# Find individual planes (identified by tail num) and their average delays
delays <- not_cancelled %>%
  group_by(tailnum) %>%
  summarize(
    delay = mean(arr_delay)
  )

ggplot(data = delays, mapping = aes(x = delay)) +
  geom_freqpoly(binwidth = 10)

# Try with number of flights vs avg delay
delays <- not_cancelled %>%
  group_by(tailnum) %>%
  summarize(
    delay = mean(arr_delay),
    n = n()
  )

# We see that variation decreases as sample size increases
ggplot(data = delays, mapping = aes(x = n, y = delay)) +
  geom_point(alpha = 1/10)
```

